const http = require('http');
const https = require('https');
const fs = require('fs');
const path = require('path');
const { URL } = require('url');
const XLSX = require('xlsx');

// 存储用户数据，用于多文件联合处理
const userDataStore = new Map(); // key: sessionId, value: storedData

// 配置
const PORT = 3000;
const API_KEY = '7a11625a-7699-4f3e-89ba-543cfba4f725'; // 用户提供的API Key
const TEMP_DIR = path.join(__dirname, 'temp');
const MAX_FILE_SIZE = 50 * 1024 * 1024; // 50MB - 单个文件大小限制
const MAX_TOTAL_SIZE = 5 * 1024 * 1024; // 5MB - 总文件大小限制
const TIMEOUT = 60000; // 60秒超时

// 确保临时目录存在
if (!fs.existsSync(TEMP_DIR)) {
    fs.mkdirSync(TEMP_DIR, { recursive: true });
}

// 解析multipart/form-data
function parseFormData(req, callback) {
    console.log('开始解析multipart/form-data表单');
    console.log('请求头content-type:', req.headers['content-type']);
    const boundary = extractBoundary(req.headers['content-type']);
    if (!boundary) {
        console.log('无法解析表单数据，缺少boundary');
        return callback(new Error('无法解析表单数据，缺少boundary'));
    }
    console.log('成功提取boundary:', boundary);
    
    // 初始化请求体
    let body = Buffer.alloc(0);

    // 'data'事件监听器已在函数开头添加
    // 确保请求超时处理
    req.setTimeout(TIMEOUT, () => {
        console.log('请求处理超时');
        req.connection.destroy();
    });

    req.on('data', (chunk) => {
        body = Buffer.concat([body, chunk]);
        console.log('接收数据块，当前总大小:', body.length, 'bytes');
        // 检查文件大小
        if (body.length > MAX_FILE_SIZE) {
            console.log('文件大小超过限制，断开连接');
            req.connection.destroy();
        }
    });

    req.on('end', () => {
        console.log('数据接收完成，总大小:', body.length, 'bytes');
        try {
            console.log('开始分割表单数据');
            const result = splitFormData(body, boundary);
            console.log('表单数据分割完成，文件数量:', result.files.length);
            callback(null, result);
        } catch (error) {
            console.error('分割表单数据时出错:', error.message);
            callback(error);
        }
    });
}

// 提取boundary
function extractBoundary(contentType) {
    if (!contentType) return null;
    const match = contentType.match(/boundary=(.+)/);
    return match ? match[1] : null;
}

// 分割表单数据 - 支持二进制文件处理
function splitFormData(body, boundary) {
    console.log('开始分割表单数据，body长度:', body.length, 'bytes');
    
    // 确保body是Buffer
    if (!Buffer.isBuffer(body)) {
        body = Buffer.from(body);
    }
    
    // 使用正确的boundary格式进行分割
    const fullBoundary = Buffer.from(`--${boundary}`);
    const result = { files: [], fields: {} };

    // 查找所有boundary位置
    let start = 0;
    while (true) {
        // 查找下一个boundary
        const boundaryIndex = body.indexOf(fullBoundary, start);
        if (boundaryIndex === -1) break;
        
        // 提取当前部分
        let part;
        if (start === 0) {
            // 第一部分可能是空的，跳过
            start = boundaryIndex + fullBoundary.length;
            continue;
        } else {
            part = body.slice(start, boundaryIndex);
            start = boundaryIndex + fullBoundary.length;
        }
        
        // 尝试解析部分
        try {
            // 查找headers和content的分隔符 (\r\n\r\n 或 \n\n)
            let headersEndIndex = part.indexOf('\r\n\r\n');
            const doubleNewlineIndex = part.indexOf('\n\n');
            
            if (headersEndIndex === -1 && doubleNewlineIndex !== -1) {
                headersEndIndex = doubleNewlineIndex;
            }
            
            if (headersEndIndex === -1) {
                console.log('跳过无法解析的部分：找不到headers和content的分隔符');
                continue;
            }
            
            // 解析headers（转换为字符串）
            const headersBuffer = part.slice(0, headersEndIndex);
            const headers = headersBuffer.toString('utf8');
            
            // 计算内容起始位置
            const contentStart = headersEndIndex + (part.indexOf('\r\n\r\n') !== -1 ? 4 : 2);
            
            // 检查是否是文件
            const filenameMatch = headers.match(/filename="([^"]*)"/);
            if (filenameMatch && filenameMatch[1]) {
                const filename = filenameMatch[1];
                console.log(`发现文件: ${filename}`);
                
                // 提取Content-Type
                const contentTypeMatch = headers.match(/Content-Type: ([^\r\n]*)/);
                const contentType = contentTypeMatch ? contentTypeMatch[1] : 'application/octet-stream';
                
                try {
                    // 提取文件内容（保留原始二进制数据）
                    let contentBuffer = part.slice(contentStart);
                    
                    // 移除末尾的\r\n如果存在
                    if (contentBuffer.length >= 2 && contentBuffer[contentBuffer.length - 2] === 0x0d && contentBuffer[contentBuffer.length - 1] === 0x0a) {
                        contentBuffer = contentBuffer.slice(0, -2);
                    }
                    
                    // 保存到临时文件
                    const tempFilename = `temp_${Date.now()}_${Math.random().toString(36).substr(2, 9)}${path.extname(filename)}`;
                    const tempPath = path.join(TEMP_DIR, tempFilename);
                    fs.writeFileSync(tempPath, contentBuffer);
                    console.log(`文件 ${filename} 已保存到临时文件: ${tempFilename}`);
                    
                    result.files.push({
                        filename,
                        contentType,
                        path: tempPath
                    });
                } catch (fileError) {
                    console.error(`保存文件 ${filename} 时出错:`, fileError.message);
                    // 继续处理其他文件，不中断整个处理流程
                }
            } else {
                // 普通字段 - 转换为字符串
                const nameMatch = headers.match(/name="([^"]*)"/);
                if (nameMatch && nameMatch[1]) {
                    const name = nameMatch[1];
                    let content = part.slice(contentStart).toString('utf8').trim();
                    
                    // 移除末尾的\r\n如果存在
                    if (content.endsWith('\r\n')) {
                        content = content.slice(0, -2);
                    } else if (content.endsWith('\n')) {
                        content = content.slice(0, -1);
                    }
                    
                    result.fields[name] = content;
                    console.log(`发现字段: ${name}=${result.fields[name]}`);
                }
            }
        } catch (error) {
            console.error(`处理部分时出错:`, error.message);
            // 继续处理其他部分，不中断整个处理流程
        }
    }

    console.log('表单数据分割完成，文件数量:', result.files.length);
    return result;
}

// 调用火山引擎API
function callVolcengineAPI(files, options, callback) {
    console.log('开始调用火山引擎API，文件数量:', files.length);
    console.log('处理选项:', options);
    
    // 获取会话ID和处理选项
    const sessionId = options.sessionId || generateSessionId();
    const combineFiles = options.combineFiles === 'true';
    const outputFormat = options.outputFormat || 'text';
    
    // 准备消息内容
    const messages = [];
    
    // 添加系统提示
    messages.push({
        role: 'system',
            content: [{
                type: 'text',
                text: `你是一个专业的数据整理助手，擅长处理各类数据资料，特别是Excel表格数据。
        请严格按照以下步骤和要求处理用户提供的数据：
        
        1. 信息提取：仔细分析所有数据，提取所有数据字段，特别关注：
           - 姓名（包括所有可能的姓名变体）
           - 身份证号码（注意识别不同格式的身份证号）
           - 手机号码（包括不同格式的手机号）
           - 工资、收入、支出等财务相关信息（如适用）
           - 其他所有存在的数据字段
        
        2. 智能归类与数据合并：
           - 主要将名字、身份证号和手机号作为联合主键进行分类汇总
           - 对于具有相同名字、身份证号和手机号组合的记录，请将所有其他数据字段的数据合并到同一类别下
           - 确保同一人员（通过三个主键识别）的所有相关数据字段都被正确聚合到一起
           - 对于缺少主键信息或无法明确归类的资料，放入"其他"类别
        
        3. 数据处理：
           - 保留所有数据列的完整信息
           - 合并时确保不丢失任何重要数据
           - 处理重复数据时，保留完整信息
           - 适应各种类型的数据结构（表格、列表、文本等）
        
        4. 多文件联合处理：
           - 如果用户要求联合处理多个文件，请将所有文件的数据作为一个整体进行分析和处理
           - 识别不同文件中相同人员的数据，进行统一归类和合并
           - 确保跨文件的数据一致性和完整性
        
        5. 工资/财务统计功能（如数据中包含此类信息）：
           - 计算每个人员的工资总额、平均工资、最高工资和最低工资
           - 按不同维度（如按人员、按单位、按项目、按时间）统计财务数据
           - 提供总额、总人数、平均值等汇总数据
        
        6. 输出格式：
           - 清晰标记每个类别的标题（如"按主键归类：张三 | 110101********1234 | 138****1234"）
           - 列出该类别下的所有相关数据字段和值
           - 保持层次分明，易于阅读
           - 对于表格数据，保持表格格式输出
           - 统计结果应以清晰的表格或列表形式呈现
           - 如果用户要求Excel格式输出，请确保输出的结构化数据适合直接转换为Excel
        
        7. 统计摘要：如果需要生成摘要，请提供以下信息：
           - 总记录数量和归类后的人员数量
           - 各类数据的汇总统计（如总额、平均值等）
           - 各类别数据分布
           - 处理过程中发现的异常情况（如有）
            
        8. 表格数据信息：
           - 在输出中包含一个特殊的标记，指示表格数据的表头和数据行
           - 格式为："[TABLE_DATA]":{"headers":["列1","列2",...],"data":[["值1","值2",...],["值3","值4",...]]}
           - 这将用于前端表格展示和Excel导出
            
        特别说明：
        - 对于Excel文件，内容已经被解析为制表符分隔的文本格式，每个工作表都有明确的标记
        - 请仔细识别表头和数据行，正确理解表格结构
        - 请以姓名、身份证号和手机号作为联合主键进行数据归类和统计分析
        - 如果有多个工作表，请注意数据之间的关联关系
        - 如果进行多文件联合处理，请确保所有文件数据作为一个整体进行分析`
            }]
        });
    
    // 添加用户提示
    let userPrompt = '请帮我整理以下数据资料，';
    if (options.usePrimaryKey === 'true' || options.sortByName === 'true' || options.sortById === 'true' || options.sortByPhone === 'true') {
        userPrompt += '主要将名字、身份证号和手机号作为联合主键进行分类汇总，其他所有数据字段在主键归类时合并，';
    }
    if (combineFiles) {
        userPrompt += '请将所有文件作为一个整体进行联合处理，识别并合并不同文件中的相关数据，';
    }
    if (options.generateSummary === 'true') {
        userPrompt += '生成统计摘要，';
    }
    // 添加工资统计功能
    if (options.enableSalaryStats === 'true') {
        userPrompt += '并进行财务统计分析（如数据包含相关信息），包括计算个人工资总额、平均工资，以及按不同维度（人员、单位、项目、时间）统计数据。';
    }
    userPrompt = userPrompt.replace(/，$/, '') + '。';
    
    // 添加输出格式要求
    if (outputFormat === 'excel') {
        userPrompt += '请确保输出格式适合Excel导出，提供结构化的数据，特别是请在输出末尾添加表格数据信息标记，格式为："[TABLE_DATA]":{"headers":["列1","列2",...],"data":[["值1","值2",...],["值3","值4",...]]}。';
    } else {
        userPrompt += '请以清晰的格式输出整理结果，包括分类情况和所有数据字段。对于表格数据，请保持表格格式输出。';
    }
    
    userPrompt += (options.enableSalaryStats === 'true' ? '统计结果请以表格或清晰列表形式呈现。' : '');
    
    // 处理会话数据
    if (combineFiles && userDataStore.has(sessionId)) {
        const storedData = userDataStore.get(sessionId);
        userPrompt += '\n\n注意：这是会话ID ' + sessionId + ' 的后续处理，请将之前处理过的数据与本次新上传的数据进行联合处理。之前的数据包含：' + storedData.filesCount + ' 个文件。';
    }
    
    const userContent = [{ type: 'text', text: userPrompt }];
    
    // 检查是否有粘贴的数据
    if (options.pastedData && options.pastedData.trim().length > 0) {
        console.log('检测到粘贴的数据，添加到请求中');
        userContent.push({
            type: 'text',
            text: `用户直接粘贴的表格数据内容：\n${options.pastedData}`
        });
    }
    
    // 读取文件内容并添加到消息中
    files.forEach((file, index) => {
        // 跳过pastedDataFile，因为我们已经处理过粘贴的数据
        if (file.filename === 'pasted_data.txt') {
            console.log('跳过虚拟粘贴数据文件');
            return;
        }
        
        // 检查文件类型
        const fileExtension = file.filename.toLowerCase().substring(file.filename.lastIndexOf('.'));
        const isExcelFile = ['.xlsx', '.xls', '.csv'].includes(fileExtension);
        
        try {
            if (isExcelFile) {
                // 对于Excel文件，提供明确的文件类型信息
                userContent.push({
                    type: 'text',
                    text: `文件${index + 1}（${file.filename}）是一个Excel表格文件。请将其视为包含结构化表格数据的文件，该文件可能包含姓名、身份证号、手机号以及财务数据等信息。请根据文件名为该Excel文件创建适当的表格结构，并按照要求以姓名、身份证号和手机号作为联合主键进行数据归类和统计分析。`
                });
                
                // 尝试以二进制方式读取并提供文件头信息作为参考
                try {
                    const fileBuffer = fs.readFileSync(file.path);
                    
                    // 使用xlsx库解析Excel文件内容
                    try {
                        console.log(`尝试解析Excel文件: ${file.filename}, 文件大小: ${fileBuffer.length} 字节`);
                        // 添加详细的解析选项和错误处理
                        const workbook = XLSX.read(fileBuffer, { 
                            type: 'buffer',
                            cellDates: true,  // 尝试处理日期格式
                            raw: false,       // 不返回原始值，处理格式化
                            cellNF: false     // 不使用数字格式
                        });
                        const sheetNames = workbook.SheetNames;
                        console.log(`成功读取工作簿，包含 ${sheetNames.length} 个工作表`);
                        let excelContent = `文件${index + 1}（${file.filename}）内容解析结果：\n`;
                        let allData = [];
                        let allHeaders = [];
                         
                        // 遍历所有工作表
                        sheetNames.forEach((sheetName, sheetIndex) => {
                            excelContent += `\n--- 工作表 ${sheetIndex + 1}：${sheetName} ---\n`;
                             
                            // 将工作表转换为JSON格式
                            const worksheet = workbook.Sheets[sheetName];
                            const jsonData = XLSX.utils.sheet_to_json(worksheet, { header: 1 });
                             
                            // 保存完整数据用于后续处理
                            if (jsonData.length > 0) {
                                allHeaders = jsonData[0]; // 使用第一个工作表的表头
                                for (let i = 1; i < jsonData.length; i++) {
                                    if (jsonData[i]) {
                                        const rowObj = {};
                                        allHeaders.forEach((header, j) => {
                                            rowObj[header] = jsonData[i][j] !== undefined ? jsonData[i][j] : '';
                                        });
                                        allData.push({ ...rowObj, '_sheet': sheetName }); // 添加工作表信息
                                    }
                                }
                            }
                             
                            // 转换为文本格式，保留表格结构
                            jsonData.forEach(row => {
                                excelContent += row.join('\t') + '\n';
                            });
                        });
                        
                        // 保存完整数据用于表格展示和Excel导出
                        const context = {};
                        context.fullData = allData;
                        context.hasHeaders = allHeaders.length > 0;
                        context.headers = allHeaders;
                        
                        // 使用解析后的数据继续处理
                        
                        // 如果内容过长，截取前10000个字符
                        if (excelContent.length > 10000) {
                            excelContent = excelContent.substring(0, 10000) + '\n...（内容过长，已截断）';
                        }
                        
                        userContent.push({
                            type: 'text',
                            text: excelContent
                        });
                    } catch (xlsxError) {
                        // 记录详细的错误信息用于调试
                        console.error(`解析Excel文件${file.filename}出错`, { 
                            message: xlsxError.message,
                            stack: xlsxError.stack,
                            fileSize: fileBuffer.length,
                            fileType: fileExtension
                        });
                        
                        // 检测文件是否为ZIP格式（xlsx文件本质就是ZIP格式）
                        const isZipFile = fileBuffer.length >= 4 && 
                                        fileBuffer[0] === 0x50 && 
                                        fileBuffer[1] === 0x4B && 
                                        fileBuffer[2] === 0x03 && 
                                        fileBuffer[3] === 0x04;
                        
                        // 提供更友好的错误信息和备选方案
                        let errorMessage = `无法使用xlsx库解析文件${file.filename}。`;
                        
                        if (isZipFile && fileExtension === '.xlsx') {
                            errorMessage += `\n\n重要提示：您上传的是标准的.xlsx文件，这种文件本质上是ZIP压缩格式（以PK开头），包含多个XML文件。`;
                            errorMessage += `\n系统能够识别这是有效的.xlsx文件格式，但在解析其中的表格数据时遇到了困难。`;
                            
                            // 添加可能的具体原因
                            errorMessage += `\n\n可能的具体原因：`;
                            errorMessage += `\n1. 文件可能使用了较新的Excel格式或特殊功能`;
                            errorMessage += `\n2. 文件可能包含复杂的公式、图表或宏`;
                            errorMessage += `\n3. 文件编码或字符集不兼容`;
                            errorMessage += `\n4. 第三方库版本限制，无法处理某些Excel特性`;
                            errorMessage += `\n5. 文件虽然是ZIP格式，但内部结构不符合Excel规范`;
                        } else {
                            errorMessage += `\n\n可能的原因：`;
                            errorMessage += `\n1. 文件格式可能不是标准的Excel格式`;
                            errorMessage += `\n2. 文件可能已损坏或受密码保护`;
                            errorMessage += `\n3. 文件版本可能不受支持`;
                        }
                        
                        // 添加文件基本信息
                        errorMessage += `\n\n文件信息：`;
                        errorMessage += `\n- 文件名: ${file.filename}`;
                        errorMessage += `\n- 文件大小: ${(fileBuffer.length / 1024).toFixed(2)} KB`;
                        errorMessage += `\n- 文件扩展名: ${fileExtension}`;
                        
                        if (isZipFile) {
                            errorMessage += `\n- 文件类型: 确认是ZIP压缩格式（标准.xlsx文件格式）`;
                        }
                        
                        // 尝试以文本方式读取文件的前几百个字符作为参考（仅对非ZIP文件）
                        if (!isZipFile) {
                            try {
                                const textContent = fileBuffer.toString('utf8', 0, 2000);
                                if (textContent.trim()) {
                                    errorMessage += `\n\n文件内容预览（文本方式）：\n${textContent.substring(0, 500)}${textContent.length > 500 ? '...' : ''}`;
                                }
                            } catch (textReadError) {
                                console.log('无法以文本方式读取文件', textReadError.message);
                            }
                        }
                        
                        // 添加处理建议，根据文件类型提供更具针对性的建议
                        errorMessage += `\n\n处理建议：`;
                        if (fileExtension === '.xlsx') {
                            errorMessage += `\n1. 强烈建议：在Excel中将文件另存为CSV格式（逗号分隔值）后重新上传，这是最兼容的方式`;
                            errorMessage += `\n2. 或者将文件另存为"Excel 97-2003工作簿(.xls)"格式`;
                            errorMessage += `\n3. 最简单的方法：直接复制Excel表格中的数据内容，粘贴到文本框中进行处理`;
                            errorMessage += `\n4. 如果文件包含多个工作表，请分别导出每个工作表为单独的CSV文件`;
                            errorMessage += `\n5. 确保文件没有使用受保护的视图或密码保护`;
                        } else {
                            errorMessage += `\n1. 请确认文件格式正确且未损坏`;
                            errorMessage += `\n2. 尝试将文件另存为CSV格式后重新上传`;
                            errorMessage += `\n3. 或尝试复制表格内容直接粘贴到文本框中`;
                        }
                        
                        userContent.push({
                            type: 'text',
                            text: errorMessage
                        });
                    }
                } catch (binaryError) {
                    console.log(`无法读取文件${file.filename}`, binaryError.message);
                    userContent.push({
                        type: 'text',
                        text: `无法读取文件${file.filename}的内容。`
                    });
                }
            } else {
                // 对于文本文件，正常读取
                try {
                    const fileContent = fs.readFileSync(file.path, 'utf8');
                    userContent.push({
                        type: 'text',
                        text: `文件${index + 1}（${file.filename}）内容：\n${fileContent}`
                    });
                } catch (textError) {
                    // 对于无法读取为文本的文件
                    userContent.push({
                        type: 'text',
                        text: `无法直接读取文件${index + 1}（${file.filename}）的内容，请根据文件名和上下文推测其内容并进行归类。`
                    });
                }
            }
        } catch (error) {
            console.error(`处理文件${file.filename}时出错:`, error.message);
            userContent.push({
                type: 'text',
                text: `处理文件${index + 1}（${file.filename}）时出错，请根据文件名推测其内容并进行归类。`
            });
        }
    });
    
    // 保存会话数据
    if (combineFiles) {
        const storedData = {
            filesCount: files.length,
            lastUpdated: new Date().toISOString(),
            // 可以添加更多需要保存的数据
        };
        userDataStore.set(sessionId, storedData);
        console.log('已保存会话数据，会话ID:', sessionId);
    }
    
    // 添加用户消息到请求中
    messages.push({
        role: 'user',
        content: userContent
    });
    
    // 构建请求数据
    const requestData = JSON.stringify({
        model: 'doubao-seed-1-6-250615',
        messages: messages
    });
    
    // 设置请求选项
    const requestOptions = {
        hostname: 'ark.cn-beijing.volces.com',
        path: '/api/v3/chat/completions',
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'Authorization': `Bearer ${API_KEY}`,
            'Content-Length': Buffer.byteLength(requestData)
        },
        timeout: TIMEOUT
    };
    
    // 发送请求
    console.log('准备发送API请求');
    const req = https.request(requestOptions, (res) => {
        console.log('收到API响应，状态码:', res.statusCode);
        let data = '';
        
        res.on('data', (chunk) => {
            data += chunk;
            console.log('接收API响应数据块，当前大小:', data.length, 'bytes');
        });
        
        res.on('end', () => {
                console.log('API响应接收完成，总大小:', data.length, 'bytes');
                try {
                    const result = JSON.parse(data);
                    console.log('API响应解析成功');
                    if (result.error) {
                        console.error('API返回错误:', result.error.message);
                        
                        // 针对令牌超限错误提供更友好的提示
                        let errorMessage = `API错误: ${result.error.message}`;
                        if (result.error.message.includes('exceed max message tokens')) {
                            errorMessage = '文件内容过多，超过了API处理限制。请尝试减少文件数量、减小文件大小或拆分文件后分批处理。';
                        }
                        
                        callback(new Error(errorMessage));
                    } else if (result.choices && result.choices.length > 0) {
                        console.log('API返回成功，获取到响应内容');
                        callback(null, result.choices[0].message.content);
                    } else {
                        console.error('API返回格式异常');
                        callback(new Error('API返回格式异常'));
                    }
                } catch (error) {
                    console.error('解析API响应失败:', error.message);
                    callback(new Error(`解析API响应失败: ${error.message}`));
                }
            });
    });
    
    req.on('error', (error) => {
        console.error('请求API失败:', error.message);
        callback(new Error(`请求API失败: ${error.message}`));
    });
    
    req.on('timeout', () => {
        console.error('API请求超时');
        req.destroy();
        callback(new Error('API请求超时'));
    });
    
    console.log('发送API请求...');
    req.write(requestData);
    req.end();
}

// 处理文件上传请求
function handleProcessData(req, res) {
    console.log('收到处理数据请求，开始解析表单数据');
    parseFormData(req, (err, formData) => {
        console.log('表单数据解析完成，文件数量：', formData?.files?.length || 0);
        if (err) {
            sendError(res, 400, err.message);
            return;
        }
        
        // 获取处理选项
        const outputFormat = formData.fields.outputFormat || 'text';
        const combineFiles = formData.fields.combineFiles === 'true';
        const sessionId = formData.fields.sessionId || generateSessionId();
        
        // 检查是否有文件或粘贴数据
        const hasFiles = formData.files.length > 0;
        const hasPastedData = formData.fields.pastedData && formData.fields.pastedData.trim().length > 0;
        
        if (!hasFiles && !hasPastedData) {
            sendError(res, 400, '请上传文件或粘贴表格数据');
            return;
        }
        
        // 检查文件总大小是否超过限制
        let totalSize = 0;
        for (const file of formData.files) {
            try {
                const stats = fs.statSync(file.path);
                totalSize += stats.size;
            } catch (error) {
                console.error(`获取文件大小失败: ${file.filename}`, error.message);
            }
        }
        
        if (totalSize > MAX_TOTAL_SIZE) {
            // 清理临时文件
            formData.files.forEach(file => {
                try { fs.unlinkSync(file.path); } catch (ignored) {}
            });
            
            sendError(res, 400, `文件总大小超过限制 (${(totalSize/1024/1024).toFixed(2)}MB > 5MB)。请尝试减少文件数量或大小。`);
            return;
        }
        
        // 调用API处理数据
        callVolcengineAPI(formData.files, {
            ...formData.fields, 
            pastedData: formData.fields.pastedData,
            outputFormat: outputFormat,
            combineFiles: combineFiles,
            sessionId: sessionId
        }, (err, aiResponse) => {
            // 清理临时文件
            formData.files.forEach(file => {
                try {
                    fs.unlinkSync(file.path);
                } catch (ignored) {}
            });
            
            if (err) {
                sendError(res, 500, err.message);
                return;
            }
            
            // 构造返回数据
            const result = {
                success: true,
                summary: extractSummary(aiResponse),
                details: aiResponse,
                fileContent: aiResponse,
                outputFormat: outputFormat,
                sessionId: sessionId,
                hasExcelData: outputFormat === 'excel', // 标记是否为Excel格式
                rawData: [] // 为联合处理准备的原始数据数组
            };
            
            // 如果有完整数据，添加到响应中
            if (aiResponse.fullData && aiResponse.fullData.length > 0) {
                result.tableData = aiResponse.fullData; // 直接返回数据数组以供表格渲染
                // 同时保留原始的headers和data格式以供其他用途
                result.headers = aiResponse.headers || [];
                result.fullData = aiResponse.fullData;
                result.rawData = aiResponse.fullData; // 用于联合处理
            }
            
            sendResponse(res, 200, result);
        });
    });
}

// 从AI响应中提取摘要
// 生成会话ID
function generateSessionId() {
    return Date.now().toString(36) + Math.random().toString(36).substr(2);
}

// 从AI响应中提取摘要
function extractSummary(fullText) {
    // 简单的摘要提取逻辑，可以根据实际情况调整
    const lines = fullText.split('\n');
    const summaryLines = [];
    
    // 提取前几行作为摘要
    for (let i = 0; i < Math.min(5, lines.length); i++) {
        const line = lines[i].trim();
        if (line && !line.startsWith('-') && !line.startsWith('•') && !line.startsWith('*')) {
            summaryLines.push(line);
            if (summaryLines.length >= 3) break;
        }
    }
    
    return summaryLines.join('\n');
}

// 发送响应
function sendResponse(res, statusCode, data) {
    res.writeHead(statusCode, {
        'Content-Type': 'application/json',
        'Access-Control-Allow-Origin': '*',
        'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
        'Access-Control-Allow-Headers': 'Content-Type, Authorization'
    });
    res.end(JSON.stringify(data));
}

// 发送错误响应
function sendError(res, statusCode, message) {
    sendResponse(res, statusCode, {
        success: false,
        error: message
    });
}

// 静态文件服务
function serveStaticFile(res, filePath) {
    fs.readFile(filePath, (err, data) => {
        if (err) {
            sendError(res, 404, '文件不存在');
            return;
        }
        
        let contentType = 'text/plain';
        if (filePath.endsWith('.html')) contentType = 'text/html';
        else if (filePath.endsWith('.css')) contentType = 'text/css';
        else if (filePath.endsWith('.js')) contentType = 'application/javascript';
        else if (filePath.endsWith('.json')) contentType = 'application/json';
        
        res.writeHead(200, {
            'Content-Type': contentType,
            'Access-Control-Allow-Origin': '*'
        });
        res.end(data);
    });
}

// 创建HTTP服务器
const server = http.createServer((req, res) => {
    const url = new URL(req.url, `http://${req.headers.host}`);
    const pathname = url.pathname;
    
    // 处理OPTIONS请求（跨域预检）
    if (req.method === 'OPTIONS') {
        res.writeHead(204, {
            'Access-Control-Allow-Origin': '*',
            'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
            'Access-Control-Allow-Headers': 'Content-Type, Authorization',
            'Access-Control-Max-Age': '86400'
        });
        res.end();
        return;
    }
    
    // API路由
    if (pathname === '/api/test' && req.method === 'GET') {
        // 简单的测试端点，用于验证服务器是否正常工作
        sendResponse(res, 200, {
            success: true,
            message: '服务器工作正常',
            timestamp: new Date().toISOString()
        });
    }
    else if (pathname === '/api/process-data' && req.method === 'POST') {
        handleProcessData(req, res);
    }
    else if (pathname === '/api/export-excel' && req.method === 'POST') {
        handleExportExcel(req, res);
    }
    // 静态文件路由
    else if (req.method === 'GET') {
        // 如果路径是根目录，提供index.html
        let filePath = pathname === '/' ? '/index.html' : pathname;
        
        // 确保文件在当前目录内（安全检查）
        const safePath = path.join(__dirname, filePath);
        if (safePath.startsWith(__dirname)) {
            serveStaticFile(res, safePath);
        } else {
            sendError(res, 403, '禁止访问');
        }
    }
    // 404路由
    else {
        sendError(res, 404, '请求的资源不存在');
    }
});

// 处理Excel导出请求
function handleExportExcel(req, res) {
    let body = Buffer.alloc(0);
    
    req.on('data', (chunk) => {
        body = Buffer.concat([body, chunk]);
        // 限制请求体大小
        if (body.length > 50 * 1024 * 1024) { // 50MB
            sendError(res, 413, '请求体过大');
            req.destroy();
        }
    });
    
    req.on('end', () => {
        try {
            const data = JSON.parse(body.toString());
            
            // 验证数据格式
            if (!data.tableData || !data.tableData.headers || !Array.isArray(data.tableData.data)) {
                sendError(res, 400, '无效的数据格式');
                return;
            }
            
            const { headers, data: tableData } = data.tableData;
            
            // 创建工作簿和工作表
            const workbook = XLSX.utils.book_new();
            
            // 准备工作表数据（包含表头行）
            const worksheetData = [headers];
            
            // 添加数据行
            tableData.forEach(row => {
                const dataRow = headers.map(header => {
                    // 如果row是对象，根据header获取值；如果是数组，直接使用对应索引
                    return typeof row === 'object' && row !== null && !Array.isArray(row) ? 
                           (row[header] !== undefined ? row[header] : '') : 
                           (row instanceof Array ? (row[headers.indexOf(header)] || '') : '');
                });
                worksheetData.push(dataRow);
            });
            
            // 创建工作表
            const worksheet = XLSX.utils.aoa_to_sheet(worksheetData);
            
            // 添加工作表到工作簿
            XLSX.utils.book_append_sheet(workbook, worksheet, '整理数据');
            
            // 生成Excel文件缓冲区
            const excelBuffer = XLSX.write(workbook, { bookType: 'xlsx', type: 'buffer' });
            
            // 设置响应头
            res.writeHead(200, {
                'Content-Type': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
                'Content-Disposition': `attachment; filename="整理数据_${new Date().toISOString().split('T')[0]}.xlsx"`,
                'Content-Length': excelBuffer.length,
                'Access-Control-Allow-Origin': '*'
            });
            
            // 发送Excel文件
            res.end(excelBuffer);
            
        } catch (error) {
            console.error('导出Excel出错:', error.message);
            sendError(res, 500, `导出Excel失败: ${error.message}`);
        }
    });
    
    req.on('error', (error) => {
        console.error('请求处理出错:', error.message);
        sendError(res, 500, '服务器内部错误');
    });
}

// 启动服务器
server.listen(PORT, () => {
    console.log(`会计数据整理服务已启动，监听端口 ${PORT}`);
    console.log(`请在浏览器中访问 http://localhost:${PORT} 使用服务`);
    console.log('注意：本服务仅用于本地测试，请勿在生产环境使用');
});

// 处理未捕获的异常
process.on('uncaughtException', (error) => {
    console.error('未捕获的异常:', error);
});

process.on('unhandledRejection', (reason, promise) => {
    console.error('未处理的Promise拒绝:', reason);
});

// 清理临时文件
process.on('exit', () => {
    try {
        const files = fs.readdirSync(TEMP_DIR);
        files.forEach(file => {
            fs.unlinkSync(path.join(TEMP_DIR, file));
        });
    } catch (ignored) {}
});